package com.itheima.leetcode.od.b.logicalsimulation;

/**
 * (B卷,100分)- 代码编辑器（Java & JS & Python）
 * <p>
 * 题目描述
 * <p>
 * 某公司为了更高效的编写代码，邀请你开发一款代码编辑器程序。
 * <p>
 * 程序的输入为 已有的代码文本和指令序列，程序需输出编辑后的最终文本。指针初始位置位于文本的开头。
 * <p>
 * 支持的指令(X为大于等于0的整数, word 为无空格的字符串)：
 * <p>
 * FORWARD X 指针向前(右)移动X,如果指针移动位置超过了文本末尾，则将指针移动到文本末尾
 * <p>
 * BACKWARD X 指针向后(左)移动X,如果指针移动位置超过了文本开头，则将指针移动到文本开头
 * <p>
 * SEARCH-FORWARD word 从指针当前位置向前查找 word 并将指针移动到word的起始位置，如果未找到则保持不变
 * <p>
 * SEARCH-BACKWARD word 在文本中向后查我 word 并将指针移动到word的起始位置，如果未找到则保持不变
 * <p>
 * INSERT word 在指针当前位置前插入word，并将指针移动到word的结尾
 * <p>
 * REPLACE word 在指针当前位置替换并插入字符(删除原有字符，并增加新的字符)
 * <p>
 * DELETE X 在指针位置删除X个字符
 * <p>
 * 输入描述
 * <p>
 * 输入的第一行为命令列表的长度K
 * <p>
 * 输入的第二行为文件中的原始文本
 * <p>
 * 接下来的K行，每行为一个指令
 * <p>
 * 输出描述
 * <p>
 * 编辑后的最终结果
 * <p>
 * 备注
 * 文本最长长度不超过 256K
 * <p>
 * 用例
 * <p>
 * 输入	1
 * <p>
 * ello
 * <p>
 * INSERT h
 * <p>
 * 输出	hello
 * 说明	在文本开头插入
 * <p>
 * 输入	2
 * <p>
 * hllo
 * <p>
 * FORWARD 1
 * <p>
 * INSERT e
 * <p>
 * 输出	hello
 * 说明	在文本的第一个位置插入
 * <p>
 * 输入	2
 * <p>
 * hell
 * <p>
 * FORWARD 1000
 * <p>
 * INSERT o
 * <p>
 * 输出	hello
 * 说明	在文本的结尾插入
 * <p>
 * 输入	1
 * <p>
 * hello
 * <p>
 * REPLACE HELLO
 * <p>
 * 输出	HELLO
 * 说明	替换
 * <p>
 * 输入	1
 * <p>
 * hello
 * <p>
 * REPLACE HELLO_WORLD
 * <p>
 * 输出	HELLO_WORLD
 * 说明	超过文本长度替换
 * <p>
 * 输入	2
 * <p>
 * hell
 * <p>
 * FORWARD 10000
 * <p>
 * REPLACE O
 * <p>
 * 输出	hellO
 * 说明	超出文本长度替换
 * <p>
 * 题目解析
 * <p>
 * 本题考察逻辑分析，以及字符串常用操作。
 * <p>
 * 本题题目描述对逻辑描述的非常清晰，大家可以对照题目描述来看下面的代码。
 * <p>
 * 其中，容易出错的点是：
 * <p>
 * SEARCH-BACKWARD 是向后查找，这个“向后”，其实是“向左”
 * <p>
 * SEARCH-FORWARD 是向前查找，这个“向前”，其实是“向右”
 * <p>
 * 假设指针位置是curIdx，原始文本是s，SEARCH-BACKWARD word，即相当于在s的0~curIdx范围反向查找word，这里容易出错的点是反向查找方法参数的含义，大家可以看下各自语言的下面方法参数的含义
 * <p>
 * Java	lastIndexOf	StringBuilder (Java Platform SE 8 ) (oracle.com)
 * <p>
 * JS	lastIndexOf	String.prototype.lastIndexOf() - JavaScript | MDN (mozilla.org)
 * <p>
 * Python	rfind	Python rfind()方法 | 菜鸟教程 (runoob.com)
 * <p>
 * <p>
 * INSERT word，这里容易出错的点是，插入word到s中后，curIdx也要更新位置到插入word的最后一个单词位置后面
 */
public class CodeEditor {
    public static void main(String[] args) {
        /*Scanner scanner = new Scanner(System.in);

        // 读取命令数量
        int k = Integer.parseInt(scanner.nextLine().trim());

        // 读取原始文本
        String text = scanner.nextLine().trim();

        // 创建编辑器实例
        Editor editor = new Editor(text);

        // 执行命令
        for (int i = 0; i < k; i++) {
            String command = scanner.nextLine().trim();
            editor.executeCommand(command);
        }

        // 输出结果
        System.out.println(editor.toString());

        scanner.close();*/

        // 读取命令数量
        int k = 1;

        // 读取原始文本
        String text = "ello";

        // 创建编辑器实例
        Editor editor = new Editor(text);

        // 执行命令
        editor.executeCommand("INSERT h");

        // 输出结果
        System.out.println(editor.toString());
    }

    static class Editor {
        private StringBuilder text;  // 文本内容

        private int cursor;         // 光标位置

        public Editor(String text) {
            this.text = new StringBuilder(text);
            this.cursor = 0;
        }

        public void forward(int x) {
            // 向前移动光标，不超过文本长度
            cursor = Math.min(text.length(), cursor + x);
        }

        public void backward(int x) {
            // 向后移动光标，不小于0
            cursor = Math.max(0, cursor - x);
        }

        public void searchForward(String word) {
            // 从当前位置向前搜索
            int pos = text.indexOf(word, cursor);
            if (pos != -1) {
                cursor = pos;
            }
        }

        public void searchBackward(String word) {
            // 从当前位置向后搜索
            String textBefore = text.substring(0, cursor);
            int pos = textBefore.lastIndexOf(word);
            if (pos != -1) {
                cursor = pos;
            }
        }

        public void insert(String word) {
            // 在当前位置插入文本
            text.insert(cursor, word);
            cursor += word.length();
        }

        public void replace(String word) {
            // 替换文本
            if (cursor >= text.length()) {
                text.append(word);
                cursor = text.length();
            } else {
                // 删除从光标开始的min(len(word), 剩余文本长度)个字符
                int deleteLength = Math.min(word.length(), text.length() - cursor);
                text.delete(cursor, cursor + deleteLength);
                text.insert(cursor, word);
                cursor += word.length();
            }
        }

        public void delete(int x) {
            // 删除字符
            if (cursor < text.length()) {
                int deleteLength = Math.min(x, text.length() - cursor);
                text.delete(cursor, cursor + deleteLength);
            }
        }

        public void executeCommand(String command) {
            if (command.isEmpty()) {
                return;
            }

            // 解析并执行命令
            String[] parts = command.split(" ", 2);
            String cmd = parts[0];

            switch (cmd) {
                case "FORWARD":
                    forward(Integer.parseInt(parts[1]));
                    break;
                case "BACKWARD":
                    backward(Integer.parseInt(parts[1]));
                    break;
                case "SEARCH-FORWARD":
                    searchForward(parts[1]);
                    break;
                case "SEARCH-BACKWARD":
                    searchBackward(parts[1]);
                    break;
                case "INSERT":
                    insert(parts[1]);
                    break;
                case "REPLACE":
                    replace(parts[1]);
                    break;
                case "DELETE":
                    delete(Integer.parseInt(parts[1]));
                    break;
            }
        }

        @Override
        public String toString() {
            return text.toString();
        }

    }
}